Computing devices, such as notebook computers, personal data assistants (PDAs), and mobile handsets, have user interface devices, which are also known as human interface devices (HID). One type of user interface devices that has become more common is touch-sensor devices, such as touch-sensor pads (also commonly referred to as touchpads), touch-sensor sliders, touch-sensor buttons, and touch-sensor keyboard. One type of touch-sensor keyboard is a capacitive sensor keyboard. Conventional touch-sensor keyboards are widely used in modern compact devices. In some conventional touch-sensor keyboards, the keyboard sensors can be connected individually to pins of a microcontroller. In other conventional keyboards, the keyboard sensors can be connected in a keyboard matrix, much like a mechanical keyboard matrix of switches at intersecting rows and columns. The keyboard keys are organized into rows and columns, such as illustrated in FIG. 1A.
FIG. 1A illustrates a conventional touch-sensor keyboard matrix 100. The conventional keyboard matrix 100 includes three rows (ROW1-3) 101 and three columns (COL1-3) 102 of capacitive keys. Each capacitive key has two segments, each segment having two sensor elements. The sensor elements opposite each other are connected to each other, creating two interwoven, yet electrically distinct, sensors for each capacitive key; there is one row sensor (hashed lines) and column sensor (white) for each capacitive key. The interwoven key structure means that a key represents activation on a row and a column at the same time. The microcontroller performs activation detection of the keys by performing an analysis of the intersections of the rows and columns. The microcontroller detects activation of a key when the row and column segment intersection has been activated, meaning both the particular row and column of sensors detect the touch. This method works well when only one key (one row and one column) is pressed at a time. If more than one key is pressed, false activations (e.g., invalid activations) can occur due to multiple row-column intersection activations.
FIG. 1B illustrates multiple activation scenarios on a conventional touch-sensor keyboard matrix. The first activation scenario a) for a single pressed key (illustrated with a shaded circle surrounding the pressed key). As described above, the conventional keyboard matrix works well when only one key (e.g., Key3) is pressed at a time. In some cases, the microcontroller can detect a simultaneous-key press, as illustrated in the second activation scenario b) for two pressed keys (e.g., Key3 and Key4) (illustrated with shaded circles surrounding the pressed keys). In this scenario, because both pressed keys are detected in the same row (e.g., ROW2) but different columns (e.g., COL1 and COL2), the microcontroller can distinguish the activation state. Although in some cases the microcontroller can distinguish the activation state, simultaneous-key presses can only be detected in a limited number of scenarios. For example, the third and fourth activation scenarios c) and d) illustrate different simultaneous-key presses that exhibit the same activation state and cannot be distinguished. In these scenarios, because the two pressed keys are detected in different rows and different columns, the microcontroller cannot distinguish the activation state in either scenario. In the third scenario c), only the two keys, Key2 and Key3, should have been activated, but instead, the microcontroller incorrectly detects activations of all four keys, Keys1-4, as false or invalid activations. Scenarios in which two or more touched keys do not share either a row or column sensor, when pressed, result in false activations.
To avoid this phenomenon, conventional keyboard design logic has been restricted to allow only one key to register as pressed by selecting only one row and column sensor at a time. The selected sensor may be determined by a sorting algorithm for signals. In another conventional keyboard design, complex timing algorithms are used to distinguish a simultaneous-key press. These conventional keyboard designs require complicated logic to determine which keys have been pressed and to distinguish the activation state for a simultaneous-key press.